In modern computer architectures, fast communication among multi-core processors makes parallel processing possible. Because large main memory configurations are commercially available and affordable, server setups with hundreds of cores and several terabytes of main memory may also be a reality.
High performance database systems, such as in-memory databases, are adapted to make use of the main memory provided by modern hardware. In such systems, relevant data may be kept in main memory, so that read operations can be executed without disk I/O. The systems are designed to reduce the number of CPU cache misses and avoid CPU stalls because of memory access. One approach for achieving this goal is using column-based storage in memory, which leads to high spatial locality of data and instructions, so the operations can be executed completely in the CPU cache without costly random memory accesses.
In a column-based storage, the entries of a column are stored in contiguous memory locations. Columnar data storage allows efficient compression, such that the relevant data can be stored in main memory with less cost because of data compression. The data structure that contains the main part of the data is called the main storage. The changes are taken over from the delta storage asynchronously at some later point in time. The separation into main and delta storage allows high compression and high write performance at the same time. The column store may implement MVCC (Multi Version Concurrency Control), which is based on having multiple versions of the same data in the database. When reading data it ensures that the operation reads the right set of versions required to get a correct and consistent view of the database. A Consistent View Manager may determine which version each operation is allowed to see depending on the current transaction isolation level.
The column store may use a delta storage—an in-memory data store that implements row-level versioning that is optimized to support real time data ingestion—to provide a high level of transaction concurrency through MVCC. In order to support these design objectives, a high performance locking mechanism is required to provide row level locking capabilities. However, existing approaches for managing locks via a lockless data structure requires excessive resources in acquiring and releasing locks. Therefore, existing approaches suffer from performance and scalability issues.